#!/usr/bin/env node

import { DatabaseManager } from '../src/database/DatabaseManager.js';
import { RedisClient } from '../src/cache/index.js';
import { CacheManager } from '../src/cache/index.js';

/**
 * 数据库初始化CLI工具
 */
class DatabaseCLI {
  private dbManager: DatabaseManager;
  private cacheManager?: CacheManager;

  constructor() {
    this.dbManager = new DatabaseManager();
  }

  /**
   * 显示帮助信息
   */
  private showHelp(): void {
    console.log(`
🗄️  MCP Server AntD 数据库管理工具

使用方法:
  npm run db:init              # 初始化数据库和种子数据
  npm run db:migrate           # 执行数据库迁移
  npm run db:seed              # 执行种子数据
  npm run db:reset             # 重置数据库（危险操作）
  npm run db:status            # 检查数据库状态
  npm run db:help              # 显示帮助信息

选项:
  --force                      # 强制重建数据库表
  --alter                      # 更新数据库表结构
  --seed <file>                # 执行特定的种子文件
  --migration <file>           # 执行特定的迁移文件
    `);
  }

  /**
   * 初始化数据库和种子数据
   */
  async initDatabase(): Promise<void> {
    try {
      console.log('🚀 开始完整初始化数据库...');
      
      // 1. 初始化数据库
      await this.dbManager.initialize();
      
      // 2. 初始化缓存系统
      await this.initializeCache();
      
      // 3. 执行种子数据
      await this.dbManager.runSeeders();
      
      console.log('🎉 数据库完整初始化成功！');
      console.log('');
      console.log('📊 接下来你可以：');
      console.log('  - 运行 npm run dev 启动开发服务器');
      console.log('  - 运行 npm run db:status 检查数据库状态');
      console.log('');
    } catch (error) {
      console.error('❌ 数据库初始化失败:', error);
      process.exit(1);
    }
  }

  /**
   * 初始化缓存系统
   */
  private async initializeCache(): Promise<void> {
    try {
      console.log('🔄 初始化缓存系统...');
      
      await RedisClient.connect();
      this.cacheManager = CacheManager.getInstance(RedisClient, this.dbManager.getConnection());
      
      console.log('✅ 缓存系统初始化完成');
    } catch (error) {
      console.warn('⚠️  缓存系统初始化失败，将以仅数据库模式运行:', error.message);
    }
  }

  /**
   * 执行数据库迁移
   */
  async runMigrations(migrationFile?: string): Promise<void> {
    try {
      await this.dbManager.initialize();
      
      if (migrationFile) {
        await this.dbManager.runMigration(migrationFile);
      } else {
        // 执行所有迁移文件
        console.log('📝 执行所有迁移文件...');
        await this.dbManager.runMigration('001-create-tables.sql');
        console.log('✅ 所有迁移执行完成');
      }
    } catch (error) {
      console.error('❌ 迁移执行失败:', error);
      process.exit(1);
    }
  }

  /**
   * 执行种子数据
   */
  async runSeeders(seedFile?: string): Promise<void> {
    try {
      await this.dbManager.initialize();
      
      if (seedFile) {
        await this.dbManager.runSeeder(seedFile);
      } else {
        await this.dbManager.runSeeders();
      }
    } catch (error) {
      console.error('❌ 种子数据执行失败:', error);
      process.exit(1);
    }
  }

  /**
   * 重置数据库（危险操作）
   */
  async resetDatabase(): Promise<void> {
    try {
      console.log('⚠️  警告：这将删除所有数据！');
      console.log('🔄 重置数据库...');
      
      await this.dbManager.initialize();
      
      // 强制重建数据库
      await this.dbManager.syncDatabase({ force: true });
      
      // 重新执行种子数据
      await this.dbManager.runSeeders();
      
      console.log('🎉 数据库重置完成！');
    } catch (error) {
      console.error('❌ 数据库重置失败:', error);
      process.exit(1);
    }
  }

  /**
   * 检查数据库状态
   */
  async checkStatus(): Promise<void> {
    try {
      console.log('📊 检查数据库状态...');
      
      await this.dbManager.initialize();
      const health = await this.dbManager.healthCheck();
      
      console.log('');
      console.log('📊 数据库状态报告:');
      console.log('==================');
      console.log(`数据库连接: ${health.database.status === 'healthy' ? '✅ 正常' : '❌ 异常'}`);
      console.log(`响应时间: ${health.database.details.responseTime}ms`);
      console.log(`数据仓库: ${health.repositories.status === 'healthy' ? '✅ 正常' : '❌ 异常'}`);
      console.log(`数据模型: ${health.models ? '✅ 已加载' : '❌ 未加载'}`);
      
      // 检查缓存状态
      if (this.cacheManager) {
        const cacheStats = await this.cacheManager.getStats();
        console.log('');
        console.log('📊 缓存状态报告:');
        console.log('==================');
        console.log(`内存缓存: ${cacheStats.memory.size}/${cacheStats.memory.maxSize} 项`);
        console.log(`Redis状态: ${cacheStats.redis.status === 'healthy' ? '✅ 正常' : '❌ 异常'}`);
        console.log(`数据库缓存: ${cacheStats.database.totalItems} 项`);
      }
      
      console.log('');
    } catch (error) {
      console.error('❌ 状态检查失败:', error);
      process.exit(1);
    }
  }

  /**
   * 执行CLI命令
   */
  async run(): Promise<void> {
    const args = process.argv.slice(2);
    const command = args[0];
    
    // 解析命令行参数
    const flags = {
      force: args.includes('--force'),
      alter: args.includes('--alter'),
      seed: args.includes('--seed') ? args[args.indexOf('--seed') + 1] : undefined,
      migration: args.includes('--migration') ? args[args.indexOf('--migration') + 1] : undefined,
    };

    try {
      switch (command) {
        case 'init':
          await this.initDatabase();
          break;
          
        case 'migrate':
          await this.runMigrations(flags.migration);
          break;
          
        case 'seed':
          await this.runSeeders(flags.seed);
          break;
          
        case 'reset':
          await this.resetDatabase();
          break;
          
        case 'status':
          await this.checkStatus();
          break;
          
        case 'help':
        case '--help':
        case '-h':
          this.showHelp();
          break;
          
        default:
          console.log('❌ 未知命令:', command);
          this.showHelp();
          process.exit(1);
      }
    } catch (error) {
      console.error('❌ 命令执行失败:', error);
      process.exit(1);
    } finally {
      // 清理资源
      try {
        await this.dbManager.close();
        if (this.cacheManager) {
          this.cacheManager.destroy();
        }
        await RedisClient.disconnect();
      } catch (error) {
        console.warn('⚠️  资源清理警告:', error.message);
      }
    }
  }
}

// 如果直接运行此文件，执行CLI
if (import.meta.url === `file://${process.argv[1]}`) {
  const cli = new DatabaseCLI();
  cli.run().catch(error => {
    console.error('❌ CLI执行失败:', error);
    process.exit(1);
  });
}